{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习工程师纳米学位\n",
    "## 模型评价与验证\n",
    "## 项目 1: 预测波士顿房价\n",
    "\n",
    "\n",
    "欢迎来到机器学习工程师纳米学位的第一个项目！在此文件中，有些示例代码已经提供，但还需要实现更多的功能来让项目成功运行。以**编程练习**开始的标题表示接下来的内容中有需要你必须实现的功能。每一部分都会有详细的指导，需要实现的部分也会在注释中以**TODO**标出。请仔细阅读所有的提示！\n",
    "\n",
    "除了实现代码外，你还**必须**回答一些与项目和实现有关的问题。每一个需要你回答的问题都会以**'问题 X'**为标题。请仔细阅读每个问题，并且在问题后的**'回答'**文字框中写出完整的答案。你的项目将会根据你对问题的回答和撰写代码所实现的功能来进行评分。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第一步. 导入数据\n",
    "在这个项目中，你将利用马萨诸塞州波士顿郊区的房屋信息数据训练和测试一个模型，并对模型的性能和预测能力进行测试。通过该数据训练后的好的模型可以被用来对房屋做特定预测---尤其是对房屋的价值。对于房地产经纪等人的日常工作来说，这样的预测模型被证明非常有价值。\n",
    "\n",
    "此项目的数据集来自[UCI机器学习知识库(数据集已下线)](https://archive.ics.uci.edu/ml/datasets.html)。波士顿房屋这些数据于1978年开始统计，共506个数据点，涵盖了麻省波士顿不同郊区房屋14种特征的信息。本项目对原始数据集做了以下处理：\n",
    "- 有16个`'MEDV'` 值为50.0的数据点被移除。 这很可能是由于这些数据点包含**遗失或看不到的值**。\n",
    "- 有1个数据点的 `'RM'` 值为8.78. 这是一个异常值，已经被移除。\n",
    "- 对于本项目，房屋的`'RM'`， `'LSTAT'`，`'PTRATIO'`以及`'MEDV'`特征是必要的，其余不相关特征已经被移除。\n",
    "- `'MEDV'`特征的值已经过必要的数学转换，**可以反映35年来市场的通货膨胀效应**。\n",
    "\n",
    "运行下面区域的代码以载入波士顿房屋数据集，以及一些此项目所需的Python库。如果成功返回数据集的大小，表示数据集已载入成功。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=6, micro=5, releaselevel='final', serial=0)\n"
     ]
    }
   ],
   "source": [
    "# 载入此项目所需要的库\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import visuals as vs # Supplementary code\n",
    "\n",
    "# 检查你的Python版本\n",
    "from sys import version_info\n",
    "if version_info.major != 3 and version_info.minor != 6:\n",
    "    raise Exception('请使用Python 3.6来完成此项目')\n",
    "print(version_info)\n",
    "\n",
    "# 让结果在notebook中显示\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boston housing dataset has 489 data points with 4 variables each.\n",
      "      RM  LSTAT  PTRATIO      MEDV\n",
      "0  6.575   4.98     15.3  504000.0\n",
      "1  6.421   9.14     17.8  453600.0\n",
      "2  7.185   4.03     17.8  728700.0\n",
      "3  6.998   2.94     18.7  701400.0\n",
      "4  7.147   5.33     18.7  760200.0\n"
     ]
    }
   ],
   "source": [
    "# 载入波士顿房屋的数据集\n",
    "data = pd.read_csv('housing.csv')\n",
    "prices = data['MEDV']\n",
    "features = data.drop('MEDV', axis=1)\n",
    "\n",
    "print(\"Boston housing dataset has {} data points with {} variables each.\".format(*data.shape))\n",
    "print(data.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第二步. 分析数据\n",
    "在项目的第一个部分，你会对波士顿房地产数据进行初步的观察并给出你的分析。通过对数据的探索来熟悉数据可以让你更好地理解和解释你的结果。\n",
    "\n",
    "由于这个项目的最终目标是建立一个预测房屋价值的模型，我们需要将数据集分为**特征(features)**和**目标变量(target variable)**。\n",
    "- **特征**：`'RM'`， `'LSTAT'`和 `'PTRATIO'`，给我们提供了每个数据点的数量相关的信息。\n",
    "- **目标变量**：`'MEDV'`，是我们希望预测的变量。\n",
    "\n",
    "他们分别被存在`features`和`prices`两个变量名中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 1：基础统计运算\n",
    "你的第一个编程练习是计算有关波士顿房价的描述统计数据。我们已为你导入了` numpy `，你需要使用这个库来执行必要的计算。这些统计数据对于分析模型的预测结果非常重要的。\n",
    "在下面的代码中，你要做的是：\n",
    "- 计算`prices`中的`'MEDV'`的最小值、最大值、均值、中值和标准差；\n",
    "- 将运算结果储存在相应的变量中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statistics for Boston housing dataset:\n",
      "\n",
      "Minimum price: $105,000.00\n",
      "Maximum price: $1,024,800.00\n",
      "Mean price: $454,342.94\n",
      "Median price $438,900.00\n",
      "Standard deviation of prices: $165,171.13\n"
     ]
    }
   ],
   "source": [
    "#TODO 1\n",
    "\n",
    "#目标：计算价值的最小值\n",
    "minimum_price = np.min(prices)\n",
    "\n",
    "#目标：计算价值的最大值\n",
    "maximum_price = np.max(prices)\n",
    "\n",
    "#目标：计算价值的平均值\n",
    "mean_price = np.mean(prices)\n",
    "\n",
    "#目标：计算价值的中值\n",
    "median_price = np.median(prices)\n",
    "\n",
    "#目标：计算价值的标准差\n",
    "std_price = np.std(prices)\n",
    "\n",
    "#目标：输出计算的结果\n",
    "print(\"Statistics for Boston housing dataset:\\n\")\n",
    "print(\"Minimum price: ${:,.2f}\".format(minimum_price))\n",
    "print(\"Maximum price: ${:,.2f}\".format(maximum_price))\n",
    "print(\"Mean price: ${:,.2f}\".format(mean_price))\n",
    "print(\"Median price ${:,.2f}\".format(median_price))\n",
    "print(\"Standard deviation of prices: ${:,.2f}\".format(std_price))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 1 - 特征观察\n",
    "\n",
    "如前文所述，本项目中我们关注的是其中三个值:`'RM'`、`'LSTAT'` 和`'PTRATIO'`，对每一个数据点:\n",
    "- `'RM'` 是该地区中每个房屋的平均房间数量；\n",
    "- `'LSTAT'` 是指该地区有多少百分比的业主属于是低收入阶层（有工作但收入微薄）；\n",
    "- `'PTRATIO'` 是该地区的中学和小学里，学生和老师的数目比（`学生/老师`）。\n",
    "\n",
    "_凭直觉，上述三个特征中对每一个来说，你认为增大该特征的数值，`'MEDV'`的值会是**增大**还是**减小**呢？每一个答案都需要你给出理由。_\n",
    "\n",
    "**提示：**你预期一个`'RM'` 值是6的房屋跟`'RM'` 值是7的房屋相比，价值更高还是更低呢？\n",
    "\n",
    "注：在机器学习和数据分析中，除了程序算法的部分，理解数据的真实含义也非常重要。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 1 - 回答：\n",
    "1. 'RM'增大，'MEDV'也会随着增大。因为房间数越多，意味着房屋面积越大，则房价就越高  \n",
    "2. 'LSTAT'增大，'MEDV'随着减小。因为低收入群体越多，有钱买房的人越少，需求少则房价就只有降低。\n",
    "3. 'PTRATIO'不断增大，'MEDV'则会减小。'PTRATIO'越大，说明该地区缺少老师，教育状况较差，因此该地区房价也会较低。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 2: 数据分割与重排\n",
    "接下来，你需要把波士顿房屋数据集分成训练和测试两个子集。通常在这个过程中，数据也会被重排列，以消除数据集中由于顺序而产生的偏差。\n",
    "在下面的代码中，你需要：\n",
    "\n",
    "使用 `sklearn.model_selection` 中的 `train_test_split`， 将`features`和`prices`的数据都分成用于训练的数据子集和用于测试的数据子集。\n",
    "  - 分割比例为：80%的数据用于训练，20%用于测试；\n",
    "  - 选定一个数值以设定 `train_test_split` 中的 `random_state` ，这会确保结果的一致性；\n",
    "\n",
    "设置了 random state 就可以保证多次运行结果一致，比如数据集分割、初始化模型、使用K折的时候。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# use cross validation to avoid overfitting \n",
    "X_train, X_test, y_train, y_test = train_test_split(features, prices, test_size=0.2, random_state=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 2 - 训练及测试\n",
    "*将数据集按一定比例分为训练用的数据集和测试用的数据集对学习算法有什么好处？*\n",
    "\n",
    "*如果用模型已经见过的数据，例如部分训练集数据进行测试，又有什么坏处？*\n",
    "\n",
    "**提示：** 如果没有数据来对模型进行测试，会出现什么问题？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 2 - 回答:\n",
    "\n",
    "* 将数据集分为训练集和测试集的好处：  \n",
    "可以使用该数据集同时用于训练和测试，而且数据没有混合使用，不会对结果造成干扰，还能对训练模型进行有效地验证和评估。测试集评估模型在未知数据的泛化能力。比如当模型出现过拟合时，模型可能在训练集上表现很好，但却不能泛化到新的数据。\n",
    "* 使用部分训练集数据测试模型的坏处：  \n",
    "使用训练集的数据测试模型会得到较好的测试结果，但这不能真实反映出该模型的好坏。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第三步. 模型衡量标准\n",
    "在项目的第三步中，你需要了解必要的工具和技巧来让你的模型进行预测。用这些工具和技巧对每一个模型的表现做精确的衡量可以极大地增强你预测的信心。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习3：定义衡量标准\n",
    "如果不能对模型的训练和测试的表现进行量化地评估，我们就很难衡量模型的好坏。通常我们会定义一些衡量标准，这些标准可以通过对某些误差或者拟合程度的计算来得到。在这个项目中，你将通过运算[*决定系数*](http://stattrek.com/statistics/dictionary.aspx?definition=coefficient_of_determination) R<sup>2</sup> 来量化模型的表现。模型的决定系数是回归分析中十分常用的统计信息，经常被当作衡量模型预测能力好坏的标准。\n",
    "\n",
    "R<sup>2</sup>的数值范围从0至1，表示**目标变量**的预测值和实际值之间的相关程度平方的百分比。一个模型的R<sup>2</sup> 值为0还不如直接用**平均值**来预测效果好；而一个R<sup>2</sup> 值为1的模型则可以对目标变量进行完美的预测。从0至1之间的数值，则表示该模型中目标变量中有百分之多少能够用**特征**来解释。_模型也可能出现负值的R<sup>2</sup>，这种情况下模型所做预测有时会比直接计算目标变量的平均值差很多。_\n",
    "\n",
    "在下方代码的 `performance_metric` 函数中，你要实现：\n",
    "- 使用 `sklearn.metrics` 中的 [`r2_score`](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.r2_score.html) 来计算 `y_true` 和 `y_predict`的R<sup>2</sup>值，作为对其表现的评判。\n",
    "- 将他们的表现评分储存到`score`变量中。\n",
    "\n",
    "或 \n",
    "\n",
    "- (可选) 不使用任何外部库，参考[决定系数的定义](https://en.wikipedia.org/wiki/Coefficient_of_determination)进行计算，这也可以帮助你更好的理解决定系数在什么情况下等于0或等于1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 3\n",
    "\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "def performance_metric(y_true, y_predict):\n",
    "    \"\"\"计算并返回预测值相比于实际值的分数\"\"\"\n",
    "\n",
    "    score = r2_score(y_true, y_predict)\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 3 可选\n",
    "# 不允许导入任何计算决定系数的库\n",
    "\n",
    "def performance_metric2(y_true, y_predict):\n",
    "    \"\"\"计算并返回预测值相比于实际值的分数\"\"\"\n",
    "\n",
    "    score = None\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 3 - 拟合程度\n",
    "\n",
    "假设一个数据集有五个数据且一个模型做出下列目标变量的预测：\n",
    "\n",
    "| 真实数值 | 预测数值 |\n",
    "| :-------------: | :--------: |\n",
    "| 3.0 | 2.5 |\n",
    "| -0.5 | 0.0 |\n",
    "| 2.0 | 2.1 |\n",
    "| 7.0 | 7.8 |\n",
    "| 4.2 | 5.3 |\n",
    "*你觉得这个模型已成功地描述了目标变量的变化吗？如果成功，请解释为什么，如果没有，也请给出原因。*  \n",
    "\n",
    "**提示**：运行下方的代码，使用`performance_metric`函数来计算模型的决定系数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model has a coefficient of determination, R^2, of 0.923.\n"
     ]
    }
   ],
   "source": [
    "# 计算这个模型的预测结果的决定系数\n",
    "score = performance_metric([3, -0.5, 2, 7, 4.2], [2.5, 0.0, 2.1, 7.8, 5.3])\n",
    "print(\"Model has a coefficient of determination, R^2, of {:.3f}.\".format(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 3 - 回答:\n",
    "因为R2=0.923，R2分数接近1，可以判断出该模型对目标变量的预测能力较好，比较好的描述了目标变量的变化。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第四步. 分析模型的表现\n",
    "在项目的第四步，我们来看一下不同参数下，模型在训练集和验证集上的表现。这里，我们专注于一个特定的算法（带剪枝的决策树，但这并不是这个项目的重点），和这个算法的一个参数 `'max_depth'`。用全部训练集训练，选择不同`'max_depth'` 参数，观察这一参数的变化如何影响模型的表现。画出模型的表现来对于分析过程十分有益，这可以让我们看到一些单看结果看不到的行为。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 学习曲线\n",
    "下方区域内的代码会输出四幅图像，它们是一个决策树模型在不同最大深度下的表现。每一条曲线都直观得显示了随着训练数据量的增加，模型学习曲线的在训练集评分和验证集评分的变化，评分使用决定系数R<sup>2</sup>。曲线的阴影区域代表的是该曲线的不确定性（用标准差衡量）。\n",
    "\n",
    "运行下方区域中的代码，并利用输出的图形回答下面的问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 根据不同的训练集大小，和最大深度，生成学习曲线\n",
    "vs.ModelLearning(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 4 - 学习曲线\n",
    "*选择上述图像中的其中一个，并给出其最大深度。随着训练数据量的增加，训练集曲线的评分有怎样的变化？验证集曲线呢？如果有更多的训练数据，是否能有效提升模型的表现呢？*\n",
    "\n",
    "**提示：**学习曲线的评分是否最终会收敛到特定的值？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 4 - 回答:\n",
    "从图中可以看出最大深度为10的决策树模型过拟合，该模型不管多大的训练数据量，在训练集上的效果都非常好，决定系数都近似为1；而验证集上的决定系数虽然前阶段在随着训练数据量的增大而在增大，但是之后和训练集的决定系数始终保持一定的差距。该模型过拟合，导致过分提取了训练集中的特征，所以即使增加训练数据，也不能有效提升该模型在验证集上的表现。  \n",
    "在传统机器学习方法中，当模型学习到一定程度以后，增大训练数据是很难有提升的，但是在深度学习中往往是一种有效的方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 复杂度曲线\n",
    "下列代码内的区域会输出一幅图像，它展示了一个已经经过训练和验证的决策树模型在不同最大深度条件下的表现。这个图形将包含两条曲线，一个是训练集的变化，一个是验证集的变化。跟**学习曲线**相似，阴影区域代表该曲线的不确定性，模型训练和测试部分的评分都用的 `performance_metric` 函数。\n",
    "\n",
    "运行下方区域中的代码，并利用输出的图形并回答下面的两个问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 根据不同的最大深度参数，生成复杂度曲线\n",
    "vs.ModelComplexity(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 5 - 偏差（bias）与方差（variance）之间的权衡取舍\n",
    "*当模型以最大深度 1训练时，模型的预测是出现很大的偏差还是出现了很大的方差？当模型以最大深度10训练时，情形又如何呢？图形中的哪些特征能够支持你的结论？*\n",
    "\n",
    "**提示：** 你如何得知模型是否出现了偏差很大或者方差很大的问题？\n",
    "\n",
    "偏差  \n",
    "在训练误差和测试误差收敛并且相当高时，这实质上表示模型具有偏差。无论向其提供多少数据，模型都无法表示基本关系，因而出现系统性的高误差。  \n",
    "方差  \n",
    "如果训练误差与测试误差之间的差距很大，这实质上表示模型具有高方差。与偏差模型不同的是，如果有更多可供学习的数据，或者能简化表示数据的最重要特征的模型，则通常可以改进具有方差的模型。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 5 - 回答:\n",
    "* 当模型最大深度为1时，训练集和验证集的决定系数较小，该模型的预测特点是高偏差和低方差，属于欠拟合。模型太简单无法捕捉数据的有效特征，不能很好的拟合测试集，训练分数、验证分数、测试分数通常都比较低。\n",
    "* 当模型最大深度为10时，训练集的决定系数接近1，而验证集的决定系数反而变小，两者差距比较大；该模型预测的特点是高方差和低偏差，属于过拟合。模型太复杂导致无法很好地泛化到其他的新数据上。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 6- 最优模型的猜测\n",
    "*结合问题 5 中的图，你认为最大深度是多少的模型能够最好地对未见过的数据进行预测？你得出这个答案的依据是什么？*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 6 - 回答:\n",
    "最大深度为4时，验证集的决定系数大，表现很好，所以该模型能很好地对未见过的数据进行预测。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 第五步. 选择最优参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 7- 网格搜索（Grid Search）\n",
    "*什么是网格搜索法？如何用它来优化模型？*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 7 - 回答:\n",
    "网格搜索法是一种指定多个超参数值的列举搜索方法，对这多个超参数的组合进行模型训练，并通过交叉验证对其进行评估，选出效果最优的超参数组合，达到优化模型的目的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 8 - 交叉验证\n",
    "- 什么是K折交叉验证法（k-fold cross-validation）？\n",
    "- [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html)是如何结合交叉验证来完成对最佳参数组合的选择的？\n",
    "- [GridSearchCV](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html)中的`'cv_results_'`属性能告诉我们什么？\n",
    "- 网格搜索时如果不使用交叉验证会有什么问题？交叉验证又是如何解决这个问题的？\n",
    "\n",
    "**提示：** 在下面 fit_model函数最后加入 `print pd.DataFrame(grid.cv_results_)` 可以帮你查看更多信息。\n",
    "\n",
    "这篇文章[“网格搜索算法与K折交叉验证”](https://zhuanlan.zhihu.com/p/25637642)详细地讲解了网格搜索算法和K折交叉验证的概念和过程，可以自己尝试运行文章后附的代码来帮助理解。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 8 - 回答：\n",
    "* k折交叉验证法就是将训练集数据分成k个子集，每个子集均做一次验证集，剩下k-1个子集作为训练集用于训练模型，这样将该模型训练k次，然后将k次的平均交叉验证识别率作为结果，并得到最终模型。\n",
    "* 网格搜索算法用于系统地遍历多种参数的组合，GridSearchCV则通过传入cv参数来与交叉验证共同确定最佳效果的参数组合。\n",
    "* 'cv_results_'能够输出一个dict，其中包括相关超参数的名称以及对应的值。比如 'mean_test_score', 'std_test_score', 'rank_test_score'等。\n",
    "* 如果不使用交叉验证，就只对模型进行一次训练和验证，很难保证反映出了该模型的真实性能。使用不同的子数据集进行多次训练和验证，求得结果的平均值，保证了结果的可靠性。较准确地表现出该模型的性能。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 4：训练最优模型\n",
    "在这个练习中，你将需要将所学到的内容整合，使用**决策树算法**训练一个模型。为了得出的是一个最优模型，你需要使用网格搜索法训练模型，以找到最佳的 `'max_depth'` 参数。你可以把`'max_depth'` 参数理解为决策树算法在做出预测前，允许其对数据提出问题的数量。决策树是**监督学习算法**中的一种。\n",
    "\n",
    "在下方 `fit_model` 函数中，你需要做的是：\n",
    "1. **定义 `'cross_validator'` 变量**: 使用 `sklearn.model_selection` 中的 [`KFold`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html) 创建一个交叉验证生成器对象;\n",
    "2. **定义 `'regressor'` 变量**: 使用  `sklearn.tree` 中的 [`DecisionTreeRegressor`](http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html) 创建一个决策树的回归函数;\n",
    "3. **定义 `'params'` 变量**: 为 `'max_depth'` 参数创造一个字典，它的值是从1至10的数组;\n",
    "4. **定义 `'scoring_fnc'` 变量**: 使用 `sklearn.metrics` 中的 [`make_scorer`](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.make_scorer.html)  创建一个评分函数；\n",
    " 将 `‘performance_metric’` 作为参数传至这个函数中；\n",
    "5. **定义 `'grid'` 变量**: 使用 `sklearn.model_selection` 中的 [`GridSearchCV`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) 创建一个网格搜索对象；将变量`'regressor'`, `'params'`, `'scoring_fnc'`和 `'cross_validator'` 作为参数传至这个对象构造函数中；\n",
    "  \n",
    "如果你对python函数的默认参数定义和传递不熟悉，可以参考这个MIT课程的[视频](http://cn-static.udacity.com/mlnd/videos/MIT600XXT114-V004200_DTH.mp4)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 4\n",
    "\n",
    "#提示: 导入 'KFold' 'DecisionTreeRegressor' 'make_scorer' 'GridSearchCV' \n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.metrics import make_scorer\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "def fit_model(X, y):\n",
    "    \"\"\" 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型\"\"\"\n",
    "    \n",
    "    cross_validator = KFold(10,shuffle=True)\n",
    "    \n",
    "    regressor = DecisionTreeRegressor()\n",
    "\n",
    "    params = {\"max_depth\": [1,2,3,4,5,6,7,8,9,10]}\n",
    "\n",
    "    scoring_fnc = make_scorer(performance_metric)\n",
    "\n",
    "    # GridSearchCV的作用就是自动调参，只要把参数输进去，就能给出最优化的结果和参数。\n",
    "    grid = GridSearchCV(estimator=regressor, param_grid=params,\n",
    "                        scoring=scoring_fnc, cv=cross_validator, return_train_score=True)\n",
    "\n",
    "    # 基于输入数据 [X,y]，进行网格搜索\n",
    "    grid = grid.fit(X, y)\n",
    "\n",
    "    # print(pd.DataFrame(grid.cv_results_))\n",
    "\n",
    "    # 返回网格搜索后的最优模型\n",
    "    return grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 4：训练最优模型 （可选）\n",
    "在这个练习中，你将需要将所学到的内容整合，使用**决策树算法**训练一个模型。为了得出的是一个最优模型，你需要使用网格搜索法训练模型，以找到最佳的 `'max_depth'` 参数。你可以把`'max_depth'` 参数理解为决策树算法在做出预测前，允许其对数据提出问题的数量。决策树是**监督学习算法**中的一种。\n",
    "\n",
    "在下方 `fit_model` 函数中，你需要做的是：\n",
    "\n",
    "- 遍历参数`‘max_depth’`的可选值 1～10，构造对应模型\n",
    "- 计算当前模型的交叉验证分数\n",
    "- 返回最优交叉验证分数对应的模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 4 可选\n",
    "\n",
    "'''\n",
    "不允许使用 DecisionTreeRegressor 以外的任何 sklearn 库\n",
    "\n",
    "提示: 你可能需要实现下面的 cross_val_score 函数\n",
    "\n",
    "def cross_val_score(estimator, X, y, scoring = performance_metric, cv=3):\n",
    "    \"\"\" 返回每组交叉验证的模型分数的数组 \"\"\"\n",
    "    scores = [0,0,0]\n",
    "    return scores\n",
    "'''\n",
    "\n",
    "def fit_model2(X, y):\n",
    "    \"\"\" 基于输入数据 [X,y]，利于网格搜索找到最优的决策树模型\"\"\"\n",
    "    \n",
    "    #最优交叉验证分数对应的最优模型\n",
    "    best_estimator = None\n",
    "\n",
    "    return best_estimator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 9 - 最优模型\n",
    "*最优模型的最大深度（maximum depth）是多少？此答案与你在**问题 6**所做的猜测是否相同？*\n",
    "\n",
    "运行下方区域内的代码，将决策树回归函数代入训练数据的集合，以得到最优化的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameter 'max_depth' is 4 for the optimal model.\n"
     ]
    }
   ],
   "source": [
    "# 基于训练数据，获得最优模型\n",
    "optimal_reg = fit_model(X_train, y_train)\n",
    "\n",
    "# 输出最优模型的 'max_depth' 参数\n",
    "print(\"Parameter 'max_depth' is {} for the optimal model.\".format(optimal_reg.get_params()['max_depth']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 9 - 回答：\n",
    "`Parameter 'max_depth' is 4 for the optimal model.`  \n",
    "最优模型的最大深度（maximum depth）是4，与在问题 6所做的猜测相同。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第六步. 做出预测\n",
    "当我们用数据训练出一个模型，它现在就可用于对新的数据进行预测。在决策树回归函数中，模型已经学会对新输入的数据*提问*，并返回对**目标变量**的预测值。你可以用这个预测来获取数据未知目标变量的信息，这些数据必须是不包含在训练数据之内的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 10 - 预测销售价格\n",
    "想像你是一个在波士顿地区的房屋经纪人，并期待使用此模型以帮助你的客户评估他们想出售的房屋。你已经从你的三个客户收集到以下的资讯:\n",
    "\n",
    "| 特征 | 客戶 1 | 客戶 2 | 客戶 3 |\n",
    "| :---: | :---: | :---: | :---: |\n",
    "| 房屋内房间总数 | 5 间房间 | 4 间房间 | 8 间房间 |\n",
    "| 社区贫困指数（％被认为是贫困阶层） | 17% | 32% | 3% |\n",
    "| 邻近学校的学生-老师比例 | 15：1 | 22：1 | 12：1 |\n",
    "\n",
    "*你会建议每位客户的房屋销售的价格为多少？从房屋特征的数值判断，这样的价格合理吗？为什么？* \n",
    "\n",
    "**提示：**用你在**分析数据**部分计算出来的统计信息来帮助你证明你的答案。\n",
    "\n",
    "运行下列的代码区域，使用你优化的模型来为每位客户的房屋价值做出预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted selling price for Client 1's home: $391,183.33\n",
      "Predicted selling price for Client 2's home: $189,123.53\n",
      "Predicted selling price for Client 3's home: $942,666.67\n"
     ]
    }
   ],
   "source": [
    "# 生成三个客户的数据\n",
    "client_data = [[5, 17, 15], # 客户 1\n",
    "               [4, 32, 22], # 客户 2\n",
    "               [8, 3, 12]]  # 客户 3\n",
    "\n",
    "# 进行预测\n",
    "predicted_price = optimal_reg.predict(client_data)\n",
    "for i, price in enumerate(predicted_price):\n",
    "    print(\"Predicted selling price for Client {}'s home: ${:,.2f}\".format(i+1, price))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 10 - 回答：\n",
    "合理。\n",
    "\n",
    "客户3的房子有8个房间，社区贫困指数最低，周围教育水平最高，理应房价该偏高，从统计数据来看，该房子的价格高于平均值，和最大值相差不多，所以客户3的房子的价格合理。  \n",
    "同理，客户2的房子房间最少，社区贫困指数最高，周围教育水平低，房价应该偏低，事实上该房子的价格低于平均值，和最小值相差不多，所以客户2的房子的价格合理。  \n",
    "客户1的房子从各房屋特征看，其房屋质量位于客户3和客户2的房子之间的，其价格也确实是在这两者之间，所以客户1的房子价格合理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 编程练习 5\n",
    "你刚刚预测了三个客户的房子的售价。在这个练习中，你将用你的最优模型在整个测试数据上进行预测, 并计算相对于目标变量的决定系数 R<sup>2</sup>的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal model has R^2 score 0.77 on test data\n"
     ]
    }
   ],
   "source": [
    "#TODO 5\n",
    "\n",
    "# 提示：你可能需要用到 X_test, y_test, optimal_reg, performance_metric\n",
    "# 提示：你可能需要参考问题10的代码进行预测\n",
    "# 提示：你可能需要参考问题3的代码来计算R^2的值\n",
    "\n",
    "predicted_price = optimal_reg.predict(X_test)\n",
    "r2 = performance_metric(y_test, predicted_price)\n",
    "print(\"Optimal model has R^2 score {:,.2f} on test data\".format(r2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题11 - 分析决定系数\n",
    "\n",
    "你刚刚计算了最优模型在测试集上的决定系数，你会如何评价这个结果？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题11 - 回答\n",
    "R^2的测试结果为0.78，该分值并不是特别高，只能说该最优模型基本符合要求。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型健壮性\n",
    "\n",
    "一个最优的模型不一定是一个健壮模型。有的时候模型会过于复杂或者过于简单，以致于难以泛化新增添的数据；有的时候模型采用的学习算法并不适用于特定的数据结构；有的时候样本本身可能有太多噪点或样本过少，使得模型无法准确地预测目标变量。这些情况下我们会说模型是欠拟合的。\n",
    "\n",
    "### 问题 12 - 模型健壮性\n",
    "\n",
    "模型是否足够健壮来保证预测的一致性？\n",
    "\n",
    "**提示**: 执行下方区域中的代码，采用不同的训练和测试集执行 `fit_model` 函数10次。注意观察对一个特定的客户来说，预测是如何随训练数据的变化而变化的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trial 1: $391,183.33\n",
      "Trial 2: $411,417.39\n",
      "Trial 3: $415,800.00\n",
      "Trial 4: $428,316.00\n",
      "Trial 5: $413,334.78\n",
      "Trial 6: $411,931.58\n",
      "Trial 7: $399,663.16\n",
      "Trial 8: $414,430.43\n",
      "Trial 9: $402,531.82\n",
      "Trial 10: $413,700.00\n",
      "\n",
      "Range in prices: $37,132.67\n"
     ]
    }
   ],
   "source": [
    "# 请先注释掉 fit_model 函数里的所有 print 语句\n",
    "vs.PredictTrials(features, prices, fit_model, client_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 12 - 回答：\n",
    "在这里10次预测是对同一间房屋的，预测值随训练数据的变化而变化。当Range in prices较小或者在能接受的范围内就可以认为模型是足够健壮来保证预测的一致性。  \n",
    "可以看到对于不同的训练集和测试集，该预测值变化差别比较小，所以该模型足够健壮。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 13 - 实用性探讨\n",
    "*简单地讨论一下你建构的模型能否在现实世界中使用？* \n",
    "\n",
    "提示：回答以下几个问题，并给出相应结论的理由：\n",
    "- *1978年所采集的数据，在已考虑通货膨胀的前提下，在今天是否仍然适用？*\n",
    "- *数据中呈现的特征是否足够描述一个房屋？*\n",
    "- *在波士顿这样的大都市采集的数据，能否应用在其它乡镇地区？*\n",
    "- *你觉得仅仅凭房屋所在社区的环境来判断房屋价值合理吗？*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题 13 - 回答：\n",
    "* 不一定，虽然考虑到未来的通货膨胀效应，对'MEDV'特征经过必要的处理。不过房价还和其他因素有关，比如政府调控，人们炒房等。这些数据只能当做一种参考。\n",
    "* 不能够，房屋的特征还有很多，比如朝向、装修、楼层等，光这三个因素是肯定不够的。\n",
    "* 不能够，这三个因素在大都市和乡镇的区别比较大，而且影响乡镇房价还可能有另外的因素。\n",
    "* 不合理，影响房价的因素有很多，还有房屋年份、周围交通、商业圈等。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可选问题 - 预测北京房价\n",
    "\n",
    "（本题结果不影响项目是否通过）通过上面的实践，相信你对机器学习的一些常用概念有了很好的领悟和掌握。但利用70年代的波士顿房价数据进行建模的确对我们来说意义不是太大。现在你可以把你上面所学应用到北京房价数据集中 `bj_housing.csv`。\n",
    "\n",
    "免责声明：考虑到北京房价受到宏观经济、政策调整等众多因素的直接影响，预测结果仅供参考。\n",
    "\n",
    "这个数据集的特征有：\n",
    "- Area：房屋面积，平方米\n",
    "- Room：房间数，间\n",
    "- Living: 厅数，间\n",
    "- School: 是否为学区房，0或1\n",
    "- Year: 房屋建造时间，年\n",
    "- Floor: 房屋所处楼层，层\n",
    "\n",
    "目标变量：\n",
    "- Value: 房屋人民币售价，万\n",
    "\n",
    "你可以参考上面学到的内容，拿这个数据集来练习数据分割与重排、定义衡量标准、训练模型、评价模型表现、使用网格搜索配合交叉验证对参数进行调优并选出最佳参数，比较两者的差别，最终得出最佳模型对验证集的预测分数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO 6\n",
    "\n",
    "# 你的代码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题14 - 北京房价预测\n",
    "你成功的用新的数据集构建了模型了吗？他能对测试数据进行验证吗？它的表现是否符合你的预期？交叉验证是否有助于提升你模型的表现？\n",
    "\n",
    "**提示：**如果你是从零开始构建机器学习的代码会让你一时觉得无从下手。这时不要着急，你要做的只是查看之前写的代码，把每一行都看明白，然后逐步构建你的模型。当中遇到什么问题也可以在我们论坛寻找答案。也许你会发现你所构建的模型的表现并没有达到你的预期，这说明机器学习并非是一项简单的任务，构建一个表现良好的模型需要长时间的研究和测试。这也是我们接下来的课程中会逐渐学到的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 问题14 - 回答"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
